package com.zengqingfa.examples.mybatisplus.interceptor;

import cn.hutool.core.collection.CollectionUtil;
import com.zengqingfa.examples.mybatisplus.annotation.FieldPermission;
import com.zengqingfa.examples.mybatisplus.dto.DynamicColumnInfoDTO;
import com.zengqingfa.examples.mybatisplus.enums.DynamicColumnModuleEnum;
import com.zengqingfa.examples.mybatisplus.service.IDynamicColumnService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.List;
import java.util.Objects;
import java.util.Properties;

/**
 * sql拦截器，通过mybatis提供的Interceptor接口实现
 */
@Component
//拦截StatementHandler类中参数类型为Statement的prepare方法（prepare=在预编译SQL前加入修改的逻辑）
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
@Slf4j
public class FieldAuthInterceptor implements Interceptor {


    @Resource
    private IDynamicColumnService dynamicColumnService;

    /**
     * 拦截sql
     *
     * @param invocation
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();

        // 通过MetaObject优雅访问对象的属性，这里是访问statementHandler的属性;：MetaObject是Mybatis提供的一个用于方便、
        // 优雅访问对象属性的对象，通过它可以简化代码、不需要try/catch各种reflect异常，同时它支持对JavaBean、Collection、Map三种类型对象的操作。
        //实际执行的sql是经过层层封装，无法利用简单的一层反射获取到需要使用提供的快捷方法或者对获取到关键数据进行拼装
        MetaObject metaObject = MetaObject.forObject(statementHandler, SystemMetaObject.DEFAULT_OBJECT_FACTORY, SystemMetaObject.DEFAULT_OBJECT_WRAPPER_FACTORY,
                new DefaultReflectorFactory());

        // 先拦截到RoutingStatementHandler，里面有个StatementHandler类型的delegate变量，其实现类是BaseStatementHandler，然后就到BaseStatementHandler的成员变量mappedStatement
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");

        // id为执行的mapper方法的全路径名，如com.cq.UserMapper.insertUser， 便于后续使用反射
        String id = mappedStatement.getId();
        // sql语句类型 select、delete、insert、update
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        // 数据库连接信息
        BoundSql boundSql = statementHandler.getBoundSql();
        // 获取到原始sql语句
        String sql = boundSql.getSql();
        log.info("SQL：{}", sql);
        // 增强sql
        // 通过反射，拦截方法上带有自定义@SqlPermission，并增强sql
        //离谱的是之前的反射无法生效，不知道为什么这个可以生效有待研究
        //非查询语句直接返回
        if (!Objects.equals(sqlCommandType, SqlCommandType.SELECT)) {
            return invocation.proceed();
        }
        // 通过类全路径获取Class对象
        Class<?> classType = Class.forName(id.substring(0, id.lastIndexOf(".")));
        // 获取当前所拦截的方法名称
        String mName = id.substring(id.lastIndexOf(".") + 1);
        String powerSql = sql;
        // 遍历类中所有方法名称，并if匹配上当前所拦截的方法
        for (Method method : classType.getDeclaredMethods()) {
            if (mName.equals(method.getName())) {
                // 判断方法上是否带有自定义@FieldPermission注解
                FieldPermission interceptorAnnotation = method.getAnnotation(FieldPermission.class);
                // 获取到当前用户，可以通过ThreadLocal中获取，这里从请求头获取
                //获取到请求的request,
                HttpServletRequest request =
                        ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
                String userCode = request.getHeader("userCode");
                if (interceptorAnnotation == null || StringUtils.isBlank(userCode)) {
                    return invocation.proceed();
                }
                //进行增强sql
                int start = 0;
                log.info("该方法需要进行数据过滤");
                //第一个from的位置
                int from = sql.indexOf("from");
                //获取到from到后面所有的sql语句
                String sqlEnd = sql.substring(from);
                //获取到当前用户拥有的字段,没有则默认字段
                List<DynamicColumnInfoDTO> columnInfos = dynamicColumnService.queryDynamicColumn(DynamicColumnModuleEnum.USER.getType(), userCode);
                if (CollectionUtil.isEmpty(columnInfos)) {
                    return invocation.proceed();
                }
                //拼接字段
                StringBuffer stringBuffer = new StringBuffer();
                for (int i = 0; i < columnInfos.size(); i++) {
                    DynamicColumnInfoDTO columnInfo = columnInfos.get(i);
                    if (i == columnInfos.size() - 1) {
                        stringBuffer.append(columnInfo.getDatabaseField() + " as " + columnInfo.getField());
                    } else {
                        stringBuffer.append(columnInfo.getDatabaseField() + " as " + columnInfo.getField() + ",");
                    }
                }
                //重新拼接
                powerSql="select "+stringBuffer.toString()+" "+sqlEnd;
            }
        }
        String mSql = sql.equals(powerSql) ? sql : powerSql;
        // 直接增强sql
        //通过反射修改sql语句
        Field field = boundSql.getClass().getDeclaredField("sql");
        field.setAccessible(true);
        field.set(boundSql, mSql);
        log.info("修改后的SQL：{}", mSql); // 打印：增强后的SQL：select * from scenario_storage limit 2
        return invocation.proceed();
    }


    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}